#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
微信同步服务
使用TaskManager管理异步任务
"""

from typing import Optional, Dict, List
import json
import time

from utils.pywechat.pywechat.WechatAuto import Contacts
from dao.mapper.wechat_data_mapper import map_wechat_user_data, batch_map_wechat_users, validate_wechat_data
from utils.async_task.task_manager import default_task_manager
from dao.contact_dao import ContactDAO

from settings.config import logger

class WechatSyncService:
    """
    微信同步服务
    使用TaskManager管理异步任务
    """
    
    def __init__(self):
        self.contact_dao = ContactDAO()
        # 注册任务处理器
        default_task_manager.register_task_handler('sync_contacts', self._sync_contacts_handler)
        
    def sync_contacts(self, account_id: Optional[str] = None) -> Dict:
        """
        同步联系人
        
        Args:
            account_id: 账号ID
            
        Returns:
            dict: 同步任务信息
        """
        # 使用TaskManager提交任务
        logger.info(f"🚀 开始同步联系人..., account_id: {account_id}")
        task_type = 'sync_contacts'
        params = {'account_id': account_id} if account_id else {}
        result = default_task_manager.submit_task(
            task_type=task_type,
            params=params,
            account_id=account_id
        )
        
        logger.info(f"🚀 正在同步联系人..., task_id: {result.get('task_id')}")
        return result
    
    def get_sync_status(self, task_id: str) -> Dict:
        """
        获取同步状态
        
        Args:
            task_id: 任务ID
            
        Returns:
            dict: 任务状态
        """
        # 使用TaskManager获取任务状态
        return default_task_manager.get_task_status(task_id)
    
    def _sync_contacts_handler(self, task_id: str, params: Dict, account_id: Optional[str] = None) -> Dict:
        """
        同步联系人任务处理器
        
        Args:
            task_id: 任务ID
            params: 任务参数
            account_id: 账号ID
            
        Returns:
            dict: 任务结果
        """
        # 如果params中有account_id，优先使用它
        if not account_id and params and 'account_id' in params:
            account_id = params.get('account_id')
            
        logger.info(f"开始处理同步联系人任务: {task_id}, 账号ID: {account_id}")
        
        # 调用微信API获取联系人详细信息
        contacts_data = self._get_contacts_data(account_id)
        
        if not contacts_data:
            raise Exception("获取联系人数据失败")

        logger.debug(f"映射后的用户数据: %s", contacts_data)
        
        # 批量映射数据
        mapped_users = batch_map_wechat_users(contacts_data)
        
        # 保存到数据库
        saved_count = self._save_contacts_to_db(mapped_users, account_id)
        
        # 返回结果
        return {
            'total': len(contacts_data),
            'saved': saved_count,
            'account_id': account_id
        }
    
    def _save_contacts_to_db(self, mapped_users: List[Dict], account_id: Optional[str]) -> int:
        """
        保存联系人到数据库
        
        Args:
            mapped_users: 映射后的用户数据
            account_id: 账号ID
            
        Returns:
            int: 保存的联系人数量
        """
        saved_count = 0
        
        logger.info(f"开始保存联系人到数据库，共 {len(mapped_users)} 个联系人")
        
        for i, user_data in enumerate(mapped_users):
            try:
                # 打印详细的调试信息
                logger.info(f"[{i+1}/{len(mapped_users)}] 准备保存用户数据: {user_data}")
                logger.info(f"用户类型: {user_data.get('user_type')}，类型: {type(user_data.get('user_type'))}")
                
                # 如果有account_id，设置用户归属
                if account_id:
                    user_data['account'] = account_id
                    logger.info(f"设置用户归属: {account_id}")
                
                # 使用ContactDAO保存或更新联系人
                result = self.contact_dao.save_or_update_contact(user_data)
                logger.info(f"保存结果: {result}")
                
                if result:
                    saved_count += 1
                    logger.info(f"成功保存用户: {user_data.get('wechat_name')}")
                else:
                    logger.warning(f"保存用户失败: {user_data.get('wechat_name')}")
                    
            except Exception as e:
                logger.error(f"保存用户数据失败: {e}")
                logger.error(f"用户数据: {user_data}")
                import traceback
                logger.error(traceback.format_exc())
                continue
        
        logger.info(f"总共保存了 {saved_count}/{len(mapped_users)} 个联系人")
        return saved_count
    

    
    def _get_contacts_data(self, account_id: str) -> List[Dict]:
        """获取微信联系人数据
        
        Args:
            account_id: 账号ID
            
        Returns:
            联系人数据列表
        """
        try:
            # 调用微信API获取联系人详细信息
            # get_friends_detail默认返回list[dict]格式
            contacts_data = Contacts.get_friends_detail(is_json=False)
            
            # 确保返回的是列表格式
            if isinstance(contacts_data, str):
                contacts_data = json.loads(contacts_data)
            
            if not isinstance(contacts_data, list):
                print(f"微信API返回数据格式异常: {type(contacts_data)}")
                return []
            
            print(f"成功获取 {len(contacts_data)} 个联系人数据")
            return contacts_data
            
        except Exception as e:
            print(f"获取联系人数据失败: {e}")
            return []
    
    def stop(self):
        """
        停止任务管理器
        """
        # 使用默认任务管理器的stop方法
        default_task_manager.stop()